1、打印从1到n的n位数
思想：先将求出是几位数，如果是3位，则就是1-999，以此输出1-n位的所有数
class Solution {
public:
    vector<int> printNumbers(int n) {
        vector<int> v;
       
        int num=0;
        while(n>0)
        {
            num+=9*pow(10,n-1);
            n-=1;
        }    
        for(int i=1;i<=num;++i)
        {
            v.push_back(i);
        }
        return v;
    }
};

2、扑克牌中的顺子，大小王为0，可以表示任何数
思想：第一步求出大小王个数，第二步相连2个牌之间的差值，diff=i-j-1；最后一步，比较大小王个数和diff个个数，如果大小王大于diff，就是顺子，否则不是顺子
总结一句，大小王可以替代任何数，也就是可以替换不相连中间的数，不够替换 ，就不是顺子
class Solution {
public:
    bool isStraight(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int zerocount=0;//计算0的个数
        int diff=0;//计算2个值之间相差个数
        for(int i=0;i<nums.size()-1;i++)
        {
            if(nums[i]==0)
            {
                zerocount++;
            }
            else if(nums[i+1]==nums[i])
            {
                return false;
            }
            else if(nums[i+1]!=nums[i]+1)
            {
                diff+=nums[i+1]-nums[i]-1;
            }
        }
        return zerocount>=diff;
    }
};
3、从上到下打印二叉树
思想：其实就是一句话，每一层的节点出完，也就是意味着下一层节点都进入了queue了
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vv;
        vector<int> v;
        if(root==nullptr)
        {
            return vv;
        }
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int size=q.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* front=q.front();
                
                v.push_back(front->val);
                q.pop();
                if(front->left)
                {
                    q.push(front->left);
                }
                if(front->right)
                {
                    q.push(front->right);
                }
                
            }
            vv.push_back(v);
            v.clear();
        }
        return vv;
    }
};

4、判断一棵树  是不是平衡二叉树
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int HTree(TreeNode* root)
    {
        if(root==nullptr)
        {
            return 0;
        }
        int left=HTree(root->left);
        int right=HTree(root->right);
        
        return left>right?(left+1):(right+1);
    }
    bool isBalanced(TreeNode* root) {
        if(root==nullptr)
        {
            return true;
        }
        int left=HTree(root->left);
        int right=HTree(root->right);
        int h=abs(left-right);
        if(h<=1)
        {
            return isBalanced(root->left)&&isBalanced(root->right);
        }
       return false;
    }
};

5、判断一棵树 是不是对称的
思想：对称也就是左右相等，左节点的左和右节点的右，左节点的右和右节点的左相等
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool _isSymmetric(TreeNode* left,TreeNode* right)
    {
        if(left==nullptr&&right==nullptr)
        {
            return true;
        }
        if(left==nullptr||right==nullptr)
        {
            return false;
        }
        if(left->val!=right->val)
        {
            return false;
        }
        return _isSymmetric(left->left,right->right)&&_isSymmetric(left->right,right->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr)
        {
            return true;
        }
        return _isSymmetric(root->left,root->right);
    }
};


